/**
 * 节点配置管理器
 * 用于管理流程节点的各种配置，包括人员编辑权限、表单数据权限等
 * 前端新增配置类型时不需要后端改动
 */

export interface NodeConfig {
  // 节点基本信息
  nodeId: string
  nodeName: string
  nodeType: string
  
  // 通用配置容器
  config: {
    // 高级配置
    advanced?: {
      // 人员编辑权限
      personnelEditPermission?: 'disabled' | 'full' | 'limited'
      // 表单数据权限（后续扩展）
      formDataPermission?: 'read' | 'write' | 'none'
      // 其他配置项...
      [key: string]: any
    }
    
    // 人员配置
    personnel?: {
      handlers?: any[]
      ccHandlers?: any[]
      notificationMethods?: string[]
    }
    
    // 其他配置类型...
    [key: string]: any
  }
}

/**
 * 节点配置管理器类
 */
export class NodeConfigManager {
  private static instance: NodeConfigManager
  private nodeConfigs: Map<string, NodeConfig> = new Map()
  
  private constructor() {}
  
  /**
   * 获取单例实例
   */
  public static getInstance(): NodeConfigManager {
    if (!NodeConfigManager.instance) {
      NodeConfigManager.instance = new NodeConfigManager()
    }
    return NodeConfigManager.instance
  }
  
  /**
   * 保存节点配置
   */
  public saveNodeConfig(nodeConfig: NodeConfig): void {
    this.nodeConfigs.set(nodeConfig.nodeId, nodeConfig)
  }
  
  /**
   * 获取节点配置
   */
  public getNodeConfig(nodeId: string): NodeConfig | undefined {
    return this.nodeConfigs.get(nodeId)
  }
  
  /**
   * 批量保存节点配置
   */
  public saveNodeConfigs(nodeConfigs: NodeConfig[]): void {
    nodeConfigs.forEach(config => this.saveNodeConfig(config))
  }
  
  /**
   * 获取所有节点配置
   */
  public getAllNodeConfigs(): NodeConfig[] {
    return Array.from(this.nodeConfigs.values())
  }
  
  /**
   * 清除节点配置
   */
  public clearNodeConfig(nodeId: string): void {
    this.nodeConfigs.delete(nodeId)
  }
  
  /**
   * 清除所有节点配置
   */
  public clearAllNodeConfigs(): void {
    this.nodeConfigs.clear()
  }
  
  /**
   * 获取节点的特定配置值
   */
  public getNodeConfigValue<T>(nodeId: string, configPath: string): T | undefined {
    const nodeConfig = this.getNodeConfig(nodeId)
    if (!nodeConfig) return undefined
    
    const pathParts = configPath.split('.')
    let current: any = nodeConfig.config
    
    for (const part of pathParts) {
      if (current && typeof current === 'object' && part in current) {
        current = current[part]
      } else {
        return undefined
      }
    }
    
    return current as T
  }
  
  /**
   * 设置节点的特定配置值
   */
  public setNodeConfigValue<T>(nodeId: string, configPath: string, value: T): void {
    const nodeConfig = this.getNodeConfig(nodeId)
    if (!nodeConfig) {
      // 如果节点配置不存在，创建一个新的
      this.saveNodeConfig({
        nodeId,
        nodeName: '',
        nodeType: '',
        config: {}
      })
    }
    
    const updatedConfig = this.getNodeConfig(nodeId)!
    const pathParts = configPath.split('.')
    let current: any = updatedConfig.config
    
    // 创建路径上的所有对象
    for (let i = 0; i < pathParts.length - 1; i++) {
      const part = pathParts[i]
      if (!(part in current) || typeof current[part] !== 'object') {
        current[part] = {}
      }
      current = current[part]
    }
    
    // 设置最终值
    const lastPart = pathParts[pathParts.length - 1]
    current[lastPart] = value
    
    this.saveNodeConfig(updatedConfig)
  }
  
  /**
   * 检查节点是否有特定配置
   */
  public hasNodeConfig(nodeId: string, configPath?: string): boolean {
    if (!configPath) {
      return this.nodeConfigs.has(nodeId)
    }
    
    return this.getNodeConfigValue(nodeId, configPath) !== undefined
  }
  
  /**
   * 从后端数据创建节点配置
   */
  public createNodeConfigFromBackendData(nodeData: any): NodeConfig {
    const config: NodeConfig = {
      nodeId: nodeData.nodeId || nodeData.id || '',
      nodeName: nodeData.nodeName || nodeData.name || '',
      nodeType: nodeData.nodeType || nodeData.type || '',
      config: {}
    }
    
    // 处理高级配置
    if (nodeData.nodeConfig && nodeData.nodeConfig.advanced) {
      config.config.advanced = { ...nodeData.nodeConfig.advanced }
    }
    
    // 处理人员配置
    if (nodeData.handlers || nodeData.ccUsers || nodeData.notificationMethods) {
      config.config.personnel = {
        handlers: nodeData.handlers || [],
        ccHandlers: nodeData.ccUsers || [],
        notificationMethods: nodeData.notificationMethods ? [nodeData.notificationMethods] : []
      }
    }
    
    return config
  }
}

/**
 * 导出单例实例
 */
export const nodeConfigManager = NodeConfigManager.getInstance()

/**
 * 工具函数：从节点数据中获取权限配置
 */
export function getNodePermission(nodeData: any, permissionType: string = 'personnelEditPermission'): string {
  // 优先级：节点配置 > 流程配置 > 默认值
  
  // 1. 从节点的nodeConfig.advanced中获取
  if (nodeData.nodeConfig && nodeData.nodeConfig.advanced && nodeData.nodeConfig.advanced[permissionType]) {
    return nodeData.nodeConfig.advanced[permissionType]
  }
  
  // 2. 从节点的直接属性中获取（兼容旧版本）
  if (nodeData[permissionType]) {
    return nodeData[permissionType]
  }
  
  // 3. 从流程数据中获取
  if (nodeData.processData && nodeData.processData.advanced && nodeData.processData.advanced[permissionType]) {
    return nodeData.processData.advanced[permissionType]
  }
  
  // 4. 默认值
  return 'full'
}

/**
 * 工具函数：检查节点权限
 */
export function checkNodePermission(nodeData: any, permissionType: string = 'personnelEditPermission', expectedValue: string): boolean {
  const actualValue = getNodePermission(nodeData, permissionType)
  return actualValue === expectedValue
}

/**
 * 使用示例：
 * 
 * 1. 获取节点权限：
 *    const permission = getNodePermission(node, 'personnelEditPermission')
 * 
 * 2. 管理节点配置：
 *    // 保存配置
 *    nodeConfigManager.saveNodeConfig(nodeConfig)
 *    
 *    // 获取配置
 *    const config = nodeConfigManager.getNodeConfig(nodeId)
 *    
 *    // 设置特定配置值
 *    nodeConfigManager.setNodeConfigValue(nodeId, 'advanced.personnelEditPermission', 'limited')
 * 
 * 3. 权限检查：
 *    const isDisabled = checkNodePermission(node, 'personnelEditPermission', 'disabled')
 *    const isLimited = checkNodePermission(node, 'personnelEditPermission', 'limited')
 *    const isFull = checkNodePermission(node, 'personnelEditPermission', 'full')
 * 
 * 4. 新增配置类型：
 *    // 在 NodeConfig 接口中添加新字段
 *    config: {
 *      advanced?: {
 *         personnelEditPermission?: 'disabled' | 'full' | 'limited'
 *         formDataPermission?: 'read' | 'write' | 'none'  // 新增配置
 *         // 其他配置项...
 *      }
 *    }
 *    
 *    // 使用新的配置
 *    const formPermission = getNodePermission(node, 'formDataPermission')
 *    const canWrite = checkNodePermission(node, 'formDataPermission', 'write')
 */
